home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / tiff / tif_apple.c < prev    next >
C/C++ Source or Header  |  1995-06-21  |  6KB  |  257 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_apple.c,v 1.17 1994/09/29 17:29:57 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994 Sam Leffler
  5.  * Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * TIFF Library Macintosh-specific routines.
  29.  *
  30.  * These routines use only Toolbox and high-level File Manager traps.
  31.  * They make no calls to the THINK C "unix" compatibility library.  Also,
  32.  * malloc is not used directly but it is still referenced internally by
  33.  * the ANSI library in rare cases.  Heap fragmentation by the malloc ring
  34.  * buffer is therefore minimized.
  35.  *
  36.  * O_RDONLY and O_RDWR are treated identically here.  The tif_mode flag is
  37.  * checked in TIFFWriteCheck().
  38.  *
  39.  * Create below fills in a blank creator signature and sets the file type
  40.  * to 'TIFF'.  It is much better for the application to do this by Create'ing
  41.  * the file first and TIFFOpen'ing it later.
  42.  */
  43.  
  44. #include "tiffiop.h"
  45. #include <Errors.h>
  46. #include <Files.h>
  47. #include <Memory.h>
  48.  
  49. #ifdef applec
  50. #define    CtoPstr    c2pstr
  51. #endif
  52.  
  53. static tsize_t
  54. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  55. {
  56.     return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ?
  57.         size : (tsize_t) -1);
  58. }
  59.  
  60. static tsize_t
  61. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  62. {
  63.     return (FSWrite((short) fd, (long*) &size, (char*) buf) == noErr ?
  64.         size : (tsize_t) -1);
  65. }
  66.  
  67. static toff_t
  68. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  69. {
  70.     long fpos, size;
  71.  
  72.     if (GetEOF((short) fd, &size) != noErr)
  73.         return EOF;
  74.     (void) GetFPos((short) fd, &fpos);
  75.  
  76.     switch (whence) {
  77.     case SEEK_CUR:
  78.         if (off + fpos > size)
  79.             SetEOF((short) fd, off + fpos);
  80.         if (SetFPos((short) fd, fsFromMark, off) != noErr)
  81.             return EOF;
  82.         break;
  83.     case SEEK_END:
  84.         if (off > 0)
  85.             SetEOF((short) fd, off + size);
  86.         if (SetFPos((short) fd, fsFromStart, off + size) != noErr)
  87.             return EOF;
  88.         break;
  89.     case SEEK_SET:
  90.         if (off > size)
  91.             SetEOF((short) fd, off);
  92.         if (SetFPos((short) fd, fsFromStart, off) != noErr)
  93.             return EOF;
  94.         break;
  95.     }
  96.  
  97.     return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF);
  98. }
  99.  
  100. static int
  101. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  102. {
  103.     return (0);
  104. }
  105.  
  106. static void
  107. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  108. {
  109. }
  110.  
  111. static int
  112. _tiffCloseProc(thandle_t fd)
  113. {
  114.     return (FSClose((short) fd));
  115. }
  116.  
  117. static toff_t
  118. _tiffSizeProc(thandle_t fd)
  119. {
  120.     long size;
  121.  
  122.     if (GetEOF((short) fd, &size) != noErr) {
  123.         TIFFError("_tiffSizeProc", "%s: Cannot get file size");
  124.         return (-1L);
  125.     }
  126.     return ((toff_t) size);
  127. }
  128.  
  129. /*
  130.  * Open a TIFF file descriptor for read/writing.
  131.  */
  132. TIFF*
  133. TIFFFdOpen(int fd, const char* name, const char* mode)
  134. {
  135.     TIFF* tif;
  136.  
  137.     tif = TIFFClientOpen(name, mode, (thandle_t) fd,
  138.         _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
  139.         _tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
  140.     if (tif)
  141.         tif->tif_fd = fd;
  142.     return (tif);
  143. }
  144.  
  145. /*
  146.  * Open a TIFF file for read/writing.
  147.  */
  148. TIFF*
  149. TIFFOpen(const char* name, const char* mode)
  150. {
  151.     static const char module[] = "TIFFOpen";
  152.     Str255 pname;
  153.     FInfo finfo;
  154.     short fref;
  155.     OSErr err;
  156.  
  157.     strcpy((char*) pname, name);
  158.     CtoPstr((char*) pname);
  159.  
  160.     switch (_TIFFgetMode(mode, module)) {
  161.     default:
  162.         return ((TIFF*) 0);
  163.     case O_RDWR | O_CREAT | O_TRUNC:
  164.         if (GetFInfo(pname, 0, &finfo) == noErr)
  165.             FSDelete(pname, 0);
  166.         /* fall through */
  167.     case O_RDWR | O_CREAT:
  168.         if ((err = GetFInfo(pname, 0, &finfo)) == fnfErr) {
  169.             if (Create(pname, 0, '    ', 'TIFF') != noErr)
  170.                 goto badCreate;
  171.             if (FSOpen(pname, 0, &fref) != noErr)
  172.                 goto badOpen;
  173.         } else if (err == noErr) {
  174.             if (FSOpen(pname, 0, &fref) != noErr)
  175.                 goto badOpen;
  176.         } else
  177.             goto badOpen;
  178.         break;
  179.     case O_RDONLY:
  180.     case O_RDWR:
  181.         if (FSOpen(pname, 0, &fref) != noErr)
  182.             goto badOpen;
  183.         break;
  184.     }
  185.     return (TIFFFdOpen((int) fref, name, mode));
  186. badCreate:
  187.     TIFFError(module, "%s: Cannot create", name);
  188.     return ((TIFF*) 0);
  189. badOpen:
  190.     TIFFError(module, "%s: Cannot open", name);
  191.     return ((TIFF*) 0);
  192. }
  193.  
  194. void
  195. _TIFFmemset(void* p, int v, size_t c)
  196. {
  197.     memset(p, v, c);
  198. }
  199.  
  200. void
  201. _TIFFmemcpy(void* d, const void* s, size_t c)
  202. {
  203.     memcpy(d, s, c);
  204. }
  205.  
  206. int
  207. _TIFFmemcmp(const void* p1, const void* p2, size_t c)
  208. {
  209.     return (memcmp(p1, p2, c));
  210. }
  211.  
  212. void *
  213. _TIFFmalloc(size_t s)
  214. {
  215.     return (NewPtr(s));
  216. }
  217.  
  218. void
  219. _TIFFfree(void* p)
  220. {
  221.     DisposePtr(p);
  222. }
  223.  
  224. void *
  225. _TIFFrealloc(void* p, size_t s)
  226. {
  227.     Ptr n = p;
  228.  
  229.     SetPtrSize(p, s);
  230.     if (MemError() && (n = NewPtr(s)) != NULL) {
  231.         BlockMove(p, n, GetPtrSize(p));
  232.         DisposePtr(p);
  233.     }
  234.     return (n);
  235. }
  236.  
  237. static void
  238. appleWarningHandler(const char* module, const char* fmt, va_list ap)
  239. {
  240.     if (module != NULL)
  241.         fprintf(stderr, "%s: ", module);
  242.     fprintf(stderr, "Warning, ");
  243.     vfprintf(stderr, fmt, ap);
  244.     fprintf(stderr, ".\n");
  245. }
  246. TIFFErrorHandler _TIFFwarningHandler = appleWarningHandler;
  247.  
  248. static void
  249. appleErrorHandler(const char* module, const char* fmt, va_list ap)
  250. {
  251.     if (module != NULL)
  252.         fprintf(stderr, "%s: ", module);
  253.     vfprintf(stderr, fmt, ap);
  254.     fprintf(stderr, ".\n");
  255. }
  256. TIFFErrorHandler _TIFFerrorHandler = appleErrorHandler;
  257.